package main

import (
	"fmt"
	"strconv"
	"time"
)

// gate66 和 gate69 是整型变量，可能用于表示或控制某些逻辑门的状态或步骤编号。
var gate66, gate69 int 

// 以下是一系列布尔变量，用于标记程序中不同阶段或功能的状态：
// prff: 可能表示某个特定处理函数的状态
// printphase1 和 printphase2: 可能用于标记第一和第二打印阶段是否完成
// rdff: 可能代表读取文件或其他资源的状态
// rdilock: 可能用于表示某种锁定机制的状态（例如，防止并发访问）
// rdsync: 可能与同步操作相关，确保多个过程按顺序执行
// rdfinish: 标记某个过程是否已完成
var prff, printphase1, printphase2, rdff, rdilock, rdsync, rdfinish bool 

// initjack 是一个包含18个通道的数组，类型为 pulse。这些通道可能用于在程序的不同部分之间传递脉冲信号或事件。
var initjack [18]chan pulse 

// initclrff 是一个长度为6的布尔数组，可能用于存储某些清除操作的结果或状态。
var initclrff [6]bool 

// initupdate 是一个整数类型的通道，可用于更新某些参数或状态信息。
var initupdate chan int 

// prttmr 是一个 time.Time 类型的变量，可能用于记录某个事件的时间点或用于计时目的。
var prttmr time.Time 

// initstat 函数返回一个字符串，表示系统状态。
func initstat() string {
    s := "" // 初始化空字符串 s 用于构建状态字符串
    for _, f := range initclrff { // 遍历 initclrff 数组中的每个布尔值
        s += b2is(f) // 将布尔值转换为字符串并追加到 s 中（假设 b2is 是一个将布尔值转换为字符串的函数）
    }
    s += b2is(rdff) // 追加 rdff 的状态
    s += b2is(prff) // 追加 prff 的状态
    s += b2is(rdfinish) // 追加 rdfinish 的状态
    s += b2is(rdilock) // 追加 rdilock 的状态
    s += b2is(rdsync) // 追加 rdsync 的状态
    s += "00" // 追加固定字符串 "00"
    s += fmt.Sprintf("%d%d", gate66, gate69) // 追加 gate66 和 gate69 的值
    return s // 返回构建的状态字符串
}

// initreset 函数重置所有状态变量和通道。
func initreset() {
    gate66 = 0 // 重置 gate66
    gate69 = 0 // 重置 gate69
    prff = false // 重置 prff
    rdff = false // 重置 rdff
    rdilock = false // 重置 rdilock
    rdsync = false // 重置 rdsync
    rdfinish = false // 重置 rdfinish
    for i := 0; i < 18; i++ { // 遍历 initjack 数组
        initjack[i] = nil // 将所有通道设置为 nil
    }
    for i := 0; i < 6; i++ { // 遍历 initclrff 数组
        initclrff[i] = false // 将所有布尔值设置为 false
    }
    initupdate <- 1 // 向 initupdate 通道发送信号，通知更新完成
}

// initplug 函数根据输入的 jack 字符串和通道 ch 设置相应的 initjack 数组元素。
func initplug(jack string, ch chan pulse) {
    switch jack[0] { // 根据 jack 字符串的第一个字符进行处理
    case 'c', 'C': // 如果是 'c' 或 'C'
        set, _ := strconv.Atoi(jack[2:]) // 将第三个字符及其后的部分转换为整数
        if set >= 1 && set <= 6 { // 检查是否在 1 到 6 之间
            switch jack[1] { // 根据第二个字符进行进一步处理
            case 'i':
                initjack[2*(set-1)] = ch // 设置对应的输入通道
            case 'o':
                initjack[2*(set-1)+1] = ch // 设置对应的输出通道
            }
        }
    case 'i', 'I': // 如果是 'i' 或 'I'
        initjack[17] = ch // 设置第 18 个位置的通道
    case 'p', 'P': // 如果是 'p' 或 'P'
        switch jack[1] { // 根据第二个字符进行处理
        case 'i':
            initjack[15] = ch // 设置第 16 个位置的通道
        case 'o':
            initjack[16] = ch // 设置第 17 个位置的通道
        }
    case 'r', 'R': // 如果是 'r' 或 'R'
        switch jack[1] { // 根据第二个字符进行处理
        case 'l':
            initjack[12] = ch // 设置第 13 个位置的通道
        case 'i':
            initjack[13] = ch // 设置第 14 个位置的通道
        case 'o':
            initjack[14] = ch // 设置第 15 个位置的通道
        }
    default:
        fmt.Println("Initiate unit jack syntax: i.jack") // 默认情况下打印提示信息
    }
    initupdate <- 1 // 向 initupdate 通道发送信号，通知更新完成
}

// initiateunit 函数是一个循环函数，处理来自 cyctrunk 通道的脉冲，并根据不同的条件执行相应的操作。
func initiateunit(cyctrunk chan pulse, button chan int) {
    var lastread time.Time // 记录上一次读取的时间

    resp := make(chan int) // 创建响应通道
    go initiateunit2() // 启动辅助函数 initiateunit2

    for {
        select {
        case p := <-cyctrunk: // 处理来自 cyctrunk 通道的脉冲
            cyc := p.val // 获取脉冲值
            if cyc&Cpp != 0 { // 检查特定条件（假设 Cpp 是一个预定义的常量）
                if gate69 == 1 { // 如果 gate69 状态为 1
                    gate66 = 0 // 重置 gate66
                    gate69 = 0 // 重置 gate69
                    handshake(1, initjack[17], resp) // 执行握手协议
                } else if gate66 == 1 { // 如果 gate66 状态为 1
                    gate69 = 1 // 设置 gate69 为 1
                }

                // 遍历 initclrff 数组，处理所有标记为 true 的状态
                for i, ff := range initclrff {
                    if ff {
                        if initjack[2*i+1] != nil { // 如果对应的输出通道不为空
                            initjack[2*i+1] <- pulse{1, resp} // 发送脉冲信号
                            <-resp // 等待响应
                        }
                        initclrff[i] = false // 重置该状态
                    }
                }

                if rdsync { // 如果 rdsync 状态为 true
                    handshake(1, initjack[14], resp) // 执行握手协议
                    rdff = false // 重置相关状态
                    rdilock = false
                    rdsync = false
                    rdfinish = false
                }

                // 如果 rdff 状态为 true 并且自上次读取以来超过 375 毫秒
                if rdff && time.Since(lastread) > 375*time.Millisecond {
                    if cardscanner != nil { // 如果卡片扫描器存在
                        if cardscanner.Scan() { // 尝试扫描卡片
                            card := cardscanner.Text() // 获取卡片信息
                            proccard(card) // 处理卡片信息
                            lastread = time.Now() // 更新最后读取时间
                            rdfinish = true // 标记读取完成
                        } else {
                            cardscanner = nil // 如果扫描失败，清除卡片扫描器
                        }
                    }
                }

                if rdfinish && rdilock { // 如果读取完成并且锁定状态为 true
                    rdsync = true // 设置同步状态
                }

                // 如果打印阶段 1 开启且自上次打印时间超过 150 毫秒
                if printphase1 && time.Since(prttmr) > 150*time.Millisecond {
                    s := doprint() // 执行打印操作
                    if punchwriter != nil { // 如果打孔机存在
                        punchwriter.WriteString(s) // 写入打印内容
                        punchwriter.WriteByte('\n') // 写入换行符
                    } else {
                        fmt.Println(s) // 否则直接打印到控制台
                    }
                    if ppunch != nil { // 如果 ppunch 通道存在
                        ppunch <- s // 发送打印内容
                    }
                    handshake(1, initjack[16], resp) // 执行握手协议
                    prttmr = time.Now() // 更新打印时间
                    printphase1 = false // 关闭打印阶段 1
                    printphase2 = true // 开启打印阶段 2
                    prff = false // 重置 prff 状态
                }

                // 如果打印阶段 2 开启且自上次打印时间超过 450 毫秒
                if printphase2 && time.Since(prttmr) > 450*time.Millisecond {
                    if prff { // 如果 prff 状态为 true
                        prttmr = time.Now() // 更新打印时间
                        printphase1 = true // 开启打印阶段 1
                    }
                    printphase2 = false // 关闭打印阶段 2
                }
            }
            if p.resp != nil {
                p.resp <- 1 // 发送响应
            }
        case bu := <-button: // 处理按钮事件
            switch bu {
            case 4:
                gate66 = 1 // 设置 gate66 状态
            case 5:
                mpclear() // 清除主处理器状态
                for i := 0; i < 20; i++ {
                    accclear(i) // 清除累加器状态
                }
                divclear() // 清除除法器状态
                multclear() // 清除乘法器状态
            case 3:
                rdff = true // 设置 rdff 状态
                rdilock = true // 设置 rdilock 状态
            }
        }
    }
}

// initiateunit2 函数监听 initupdate 通道和其他 initjack 通道上的事件，并相应地更新状态。
func initiateunit2() {
    initupdate = make(chan int) // 创建 initupdate 通道

    for {
        select {
        case <-initupdate: // 监听 initupdate 通道（此处没有具体操作）
            // 空语句，仅作为占位符
        case p := <-initjack[12]: // 处理 initjack[12] 上的事件
            rdilock = true // 设置 rdilock 状态
            if p.resp != nil {
                p.resp <- 1 // 发送响应
            }
        case p := <-initjack[13]: // 处理 initjack[13] 上的事件
            rdff = true // 设置 rdff 状态
            if p.resp != nil {
                p.resp <- 1 // 发送响应
            }
        case p := <-initjack[15]: // 处理 initjack[15] 上的事件
            if !printphase1 { // 如果打印阶段 1 未开启
                prff = true // 设置 prff 状态
                if !printphase2 { // 如果打印阶段 2 也未开启
                    printphase1 = true // 开启打印阶段 1
                    prttmr = time.Now() // 更新打印时间
                }
            }
            if p.resp != nil {
                p.resp <- 1 // 发送响应
            }
        case p := <-initjack[0]: // 处理 initjack[0] 上的事件
            initclrff[0] = true // 设置 initclrff[0] 状态
            if p.resp != nil {
                p.resp <- 1 // 发送响应
            }
        case p := <-initjack[2]: // 处理 initjack[2] 上的事件
            initclrff[1] = true // 设置 initclrff[1] 状态
            if p.resp != nil {
                p.resp <- 1 // 发送响应
            }
        case p := <-initjack[4]: // 处理 initjack[4] 上的事件
            initclrff[2] = true // 设置 initclrff[2] 状态
            if p.resp != nil {
                p.resp <- 1 // 发送响应
            }
        case p := <-initjack[6]: // 处理 initjack[6] 上的事件
            initclrff[3] = true // 设置 initclrff[3] 状态
            if p.resp != nil {
                p.resp <- 1 // 发送响应
            }
        case p := <-initjack[8]: // 处理 initjack[8] 上的事件
            initclrff[4] = true // 设置 initclrff[4] 状态
            if p.resp != nil {
                p.resp <- 1 // 发送响应
            }
        case p := <-initjack[10]: // 处理 initjack[10] 上的事件
            initclrff[5] = true // 设置 initclrff[5] 状态
            if p.resp != nil {
                p.resp <- 1 // 发送响应
            }
        }
    }
}
